#!/usr/bin/env python

# -------------------------------
# projects/python/collatz/main.py
# Copyright (C) 2009
# Glenn P. Downing
# -------------------------------

# To run the program
#     main.py < Collatz.in > Collatz.out

# To document the program
#     pydoc -w main

# -------
# globals
# -------

i = 0 # input: don't change after reading
j = 0 # input: don't change after reading
v = 0 # output

# pre-calculated first and last 100 cycle lengths
cycles = {1 : 1 , 2 : 2 , 3 : 8 , 4 : 3 , 5 : 6 , 6 : 9 , 7 : 17 , 8 : 4 , 9 : 20 , 10 : 7 , 
          11 : 15 , 12 : 10 , 13 : 10 , 14 : 18 , 15 : 18 , 16 : 5 , 17 : 13 , 18 : 21 , 
          19 : 21 , 20 : 8 , 21 : 8 , 22 : 16 , 23 : 16 , 24 : 11 , 25 : 24 , 26 : 11 , 
          27 : 112 , 28 : 19 , 29 : 19 , 30 : 19 , 31 : 107 , 32 : 6 , 33 : 27 , 34 : 14 , 
          35 : 14 , 36 : 22 , 37 : 22 , 38 : 22 , 39 : 35 , 40 : 9 , 41 : 110 , 42 : 9 , 
          43 : 30 , 44 : 17 , 45 : 17 , 46 : 17 , 47 : 105 , 48 : 12 , 49 : 25 , 50 : 25 , 
          51 : 25 , 52 : 12 , 53 : 12 , 54 : 113 , 55 : 113 , 56 : 20 , 57 : 33 , 58 : 20 , 
          59 : 33 , 60 : 20 , 61 : 20 , 62 : 108 , 63 : 108 , 64 : 7 , 65 : 28 , 66 : 28 , 
          67 : 28 , 68 : 15 , 69 : 15 , 70 : 15 , 71 : 103 , 72 : 23 , 73 : 116 , 74 : 23 , 
          75 : 15 , 76 : 23 , 77 : 23 , 78 : 36 , 79 : 36 , 80 : 10 , 81 : 23 , 82 : 111 , 
          83 : 111 , 84 : 10 , 85 : 10 , 86 : 31 , 87 : 31 , 88 : 18 , 89 : 31 , 90 : 18 , 
          91 : 93 , 92 : 18 , 93 : 18 , 94 : 106 , 95 : 106 , 96 : 13 , 97 : 119 , 98 : 26 , 
          99 : 26 , 100 : 26, 999900 : 114 , 999901 : 114 , 999902 : 140 , 999903 : 140 , 
          999904 : 259 , 999905 : 153 , 999906 : 259 , 999907 : 259 , 999908 : 114 , 
          999909 : 114 , 999910 : 114 , 999911 : 259 , 999912 : 259 , 999913 : 114 , 
          999914 : 259 , 999915 : 259 , 999916 : 114 , 999917 : 114 , 999918 : 114 , 
          999919 : 259 , 999920 : 184 , 999921 : 259 , 999922 : 140 , 999923 : 140 , 
          999924 : 184 , 999925 : 184 , 999926 : 140 , 999927 : 140 , 999928 : 184 , 
          999929 : 259 , 999930 : 184 , 999931 : 114 , 999932 : 114 , 999933 : 114 , 
          999934 : 114 , 999935 : 259 , 999936 : 47 , 999937 : 153 , 999938 : 114 , 
          999939 : 114 , 999940 : 114 , 999941 : 114 , 999942 : 114 , 999943 : 140 , 
          999944 : 259 , 999945 : 114 , 999946 : 259 , 999947 : 114 , 999948 : 259 , 
          999949 : 259 , 999950 : 140 , 999951 : 140 , 999952 : 259 , 999953 : 259 , 
          999954 : 114 , 999955 : 114 , 999956 : 259 , 999957 : 259 , 999958 : 259 , 
          999959 : 259 , 999960 : 259 , 999961 : 259 , 999962 : 259 , 999963 : 259 , 
          999964 : 114 , 999965 : 114 , 999966 : 114 , 999967 : 140 , 999968 : 109 , 
          999969 : 114 , 999970 : 259 , 999971 : 259 , 999972 : 114 , 999973 : 114 , 
          999974 : 114 , 999975 : 114 , 999976 : 109 , 999977 : 114 , 999978 : 109 , 
          999979 : 259 , 999980 : 114 , 999981 : 114 , 999982 : 114 , 999983 : 166 , 
          999984 : 109 , 999985 : 114 , 999986 : 114 , 999987 : 114 , 999988 : 109 , 
          999989 : 109 , 999990 : 166 , 999991 : 166 , 999992 : 114 , 999993 : 166 , 
          999994 : 114 , 999995 : 259 , 999996 : 114 , 999997 : 114 , 999998 : 259 , 
          999999 : 259 , 1000000 : 153}

# -----------
# InputReader
# -----------
class InputReader (object) :
    def read (self) :
        return raw_input()


# ------------
# OutputWriter
# ------------
class OutputWriter (object) :
    def write (self, *a) :
        for w in a :
            print w,
        print


# -------
# my_read
# -------
def my_read (r) :
    """
    reads an int into i and j
    return true if that succeeds, false otherwise
    """
    global i
    global j
    try :
        s = r.read()
    except EOFError :
        return False
    l = s.split()
    i = int(l[0])
    j = int(l[1])
    return True

# -------
# my_eval
# -------

def my_eval () :
    """
    computes the max cycle length in the range [i, j]
    and stores the result in v
    """
    global i
    global j
    global v
    global cycles
    
    assert i != 0
    assert j != 0
    
    v = 0
    current_cycle = 0
    
    #sort end points
    if (i < j) :
        min = i
        max = j
    else :
        min = j
        max = i
        
    assert min != 0
    assert max != 0
    assert max >= min
    
            
    for n in range(min,max+1) :
            # if not on cache, calculate cycle length and add to cache 
            if(n not in cycles) :
                cycles[n] = comp_cycle (n)
                
            current_cycle = cycles[n]
            if(current_cycle > v) :
                    v = current_cycle 

                   
# -------
# comp_cycle
# -------
def comp_cycle (n) :
    """
    computes the cycle length of any number 0<n<1,000,000
    and returns the result
    """

    if (n == 1) :
        return 1
    # if even, divide by 2
    if ((n % 2) == 0) :
        return 1 + comp_cycle(n / 2)
    # if odd, do 3n+1 and then divide by 2
    return 2 + comp_cycle(n + (n >> 1) + 1)


# --------
# my_print
# --------
def my_print (w) :
    """
    writes the values of i, j, and v
    """
    w.write(i, j, v)


# ----
# main
# ----
def main () :
    """
    runs the program
    """
    while my_read(InputReader()) :
        my_eval()
        my_print(OutputWriter())
        

if __name__ == "__main__" :
    main()
